package com.ruoyi.controller;

import com.ruoyi.domain.DeployRequest;
import com.ruoyi.domain.TaskDTO;
import com.ruoyi.engine.service.IBpmProcessDefinitionService;
import org.camunda.bpm.engine.*;
import org.camunda.bpm.engine.history.HistoricTaskInstance;
import org.camunda.bpm.engine.repository.Deployment;
import org.camunda.bpm.engine.runtime.ProcessInstance;
import org.camunda.bpm.engine.task.Task;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/t")
public class ProcessController {

    @Autowired
    private RepositoryService repositoryService;
    @Autowired
    private RuntimeService runtimeService;
    @Autowired
    private TaskService taskService;

    @Autowired
    private IBpmProcessDefinitionService iBpmProcessDefinitionService;
    // 部署流程（接收前端 XML）
    @PostMapping("/deploy")
    public String deployProcess(@RequestBody DeployRequest deployRequest) {
        Deployment deployment = repositoryService.createDeployment()
                .name(deployRequest.getProcessKey() + "-deployment")
                .addString(deployRequest.getProcessKey() + ".bpmn", deployRequest.getBpmnXml())
                .deploy();
        return "部署成功，部署 ID：" + deployment.getId();
    }
    // 正常删除流程实例（触发结束事件）
    @DeleteMapping("/{instanceId}")
    public void deleteProcessInstance(@PathVariable String instanceId) {
        try {
            // 第一个参数：实例 ID；第二个参数：删除原因（可选，用于日志记录）
            runtimeService.deleteProcessInstance(instanceId, "手动删除实例");
        } catch (ProcessEngineException e) {
            if (e.getMessage().contains("no process instance found with id")) {
                throw new RuntimeException("实例不存在", e);
            }
            throw e; // 其他异常抛给全局异常处理器
        }
    }
    // 启动流程实例
    @PostMapping("/process/start")
    public String startProcess(@RequestParam("processKey") String processKey) {
        // 创建流程变量，将业务数据ID存入
        Map<String, Object> variables = new HashMap<>();
        variables.put("remarkId", 1L); // 变量名可自定义，建议与业务含义一致
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(processKey,variables);

        return "流程实例启动成功，ID：" + processInstance.getId();
    }

    // 查询待办任务（按负责人）
    @GetMapping("/task/list")
    public List<TaskDTO> getTasks(@RequestParam("assignee") String assignee) {
        // 查询原始任务列表
        List<ProcessInstance> tasks = runtimeService.createProcessInstanceQuery()
                .processDefinitionKey("integralProcess") // 流程key，对应BPMN中process的id
                .active() // 只查正在运行的实例
                .list();

// 2. 逐个检查实例的当前节点和状态
        for (ProcessInstance instance : tasks) {
            System.out.println("实例ID：" + instance.getId() + "，是否结束：" + instance.isEnded());
            // 查当前活跃节点（只有未结束的实例有活跃节点）
            if (!instance.isEnded()) {
                List<String> activeNodes = runtimeService.getActiveActivityIds(instance.getId());
                System.out.println("活跃节点：" + activeNodes); // 是否包含 "Activity_1en0wz0"？
            }
        }
        List<Task> auditTasks = taskService.createTaskQuery()
//                .taskDefinitionKey("Activity_1en0wz0") // 精准定位用户任务节点
//                .processDefinitionKey("integralProcess")
                .list();

        System.out.println("积分审核任务总数：" + auditTasks.size()); // 应该是3个
        for (Task task : auditTasks) {
            System.out.println("任务ID：" + task.getId() +
                    "，实际assignee：" + task.getAssignee() + // 看这里的真实值！
                    "，任务名称：" + task.getName());
        }
        return tasks.stream().map(task -> {
            TaskDTO dto = new TaskDTO();
            dto.setId(task.getId());


            // 获取流程实例ID（通过任务获取流程实例ID）
            String processInstanceId = task.getProcessInstanceId();

            // 通过流程实例ID获取流程变量（包括dataId）
            Map<String, Object> variables = runtimeService.getVariables(processInstanceId);
            Long dataId = (Long) variables.get("integralId"); // 提取业务数据ID
            dto.setIntegralId(String.valueOf(dataId)); // 将dataId存入DTO
//            query.taskAssigneeIn(assignees.toArray(new String[0]))
            return dto;
        }).collect(Collectors.toList());
//        // 查询原始任务列表
//        List<Task> tasks = taskService.createTaskQuery()
//                .taskAssignee(assignee)
//                .list();
//        return tasks.stream().map(task -> {
//            TaskDTO dto = new TaskDTO();
//            dto.setId(task.getId());
//            dto.setName(task.getName());
//            dto.setAssignee(task.getAssignee());
//            dto.setCreateTime(task.getCreateTime());
//
//            // 获取流程实例ID（通过任务获取流程实例ID）
//            String processInstanceId = task.getProcessInstanceId();
//
//            // 通过流程实例ID获取流程变量（包括dataId）
//            Map<String, Object> variables = runtimeService.getVariables(processInstanceId);
//            Long dataId = (Long) variables.get("remarkId"); // 提取业务数据ID
//            dto.setRemarkId(dataId); // 将dataId存入DTO
////            query.taskAssigneeIn(assignees.toArray(new String[0]))
//            return dto;
//        }).collect(Collectors.toList());
        // 转换为 DTO
//        return tasks.stream()
//                .map(task -> {
//                    TaskDTO dto = new TaskDTO();
//                    dto.setId(task.getId());
//                    dto.setName(task.getName());
//                    dto.setAssignee(task.getAssignee());
//                    dto.setCreateTime(task.getCreateTime());
//                    return dto;
//                })
//                .collect(Collectors.toList());
    }
    // 删除部署（可级联删除实例）
    @DeleteMapping("/a/{deploymentId}")
    public void deleteDeployment(
            @PathVariable String deploymentId,
            @RequestParam(defaultValue = "true") boolean cascade) {

        repositoryService.deleteDeployment(deploymentId, cascade);
        // 参数说明：
        // 1. deploymentId - 部署 ID
        // 2. cascade=true - 级联删除所有相关的流程实例和历史数据
    }
    @PutMapping("/{definitionId}/suspend")
    public void suspendProcessDefinition(@PathVariable String definitionId) {
        repositoryService.suspendProcessDefinitionById(definitionId, true, null);
        // 参数说明：
        // 1. definitionId - 流程定义 ID
        // 2. cascade=true - 是否级联挂起已运行的实例
        // 3. executionDate=null - 立即执行，不设置延迟时间
    }

    // 挂起流程定义（根据 Key，挂起所有版本）
    @PutMapping("/key/{definitionKey}/suspend")
    public void suspendProcessDefinitionByKey(@PathVariable String definitionKey) {
        repositoryService.suspendProcessDefinitionByKey(definitionKey, true, null);
    }
//    @GetMapping("/task/list")
//    public List getTasks(@RequestParam("assignee") String assignee) {
//        return taskService.createTaskQuery()
//                .taskAssignee(assignee)
//                .list();
//    }

    // 完成任务（审批）
    @PostMapping("/task/complete")
    public String completeTask(@RequestParam("taskId") String taskId,
                               @RequestParam Map<String, Object> variables) {
        taskService.complete(taskId, variables);
        return "任务完成";
    }
    //获取运行的实li
    @GetMapping("/process/instance/running")
    public List<ProcessInstance> getRunningProcessInstances() {
        return runtimeService.createProcessInstanceQuery()
                .active() // 仅活跃实例
                .list();
    }
    //终止实例
    @PostMapping("/process/instance/terminate/{processInstanceId}")
    public String terminateProcessInstance(@PathVariable String processInstanceId) {
        runtimeService.deleteProcessInstance(processInstanceId, "手动终止原因");
        return "流程实例已终止";
    }
    //查看已经完成历史任务
    @Autowired
    private HistoryService historyService;
    @GetMapping("/history/task")
    public List<HistoricTaskInstance> getHistoricTasks(@RequestParam String assignee) {
        return historyService.createHistoricTaskInstanceQuery()
                .taskAssignee(assignee)
                .finished() // 已完成的任务
                .list();
    }
}
